/*
* Array是数组,有序列表,数据中每项都可以保存任何类型的数据
* 创建Array的几种方式
* 1) const arr = new Array()
* 2) const arr = new Array(10)  //创建一个长度是10的数组
* 3) const colors = new Array('red', 'blue', 'orange') // 创建数组,并初始化数据中的值
* 4) const colors = ['red', 'blue', 'orange'] // 常用,实际开发用这种方式
* 5) const arr = [] // 常用,实际开发用这种方式
* */

{
  console.log('--------------------数组输出,length属性--------------------')
  // 数组输出,length属性
  const colors = ['red', 'blue', 'orange']
  console.log(colors[0]) // 输出第一项
  colors[1] = 'nike'  // 修改第二项
  colors[3] = 'adidas' // 新增第四项
  console.log(colors)
  console.log(colors.length) // length: 可向数组末尾新增或者删除
  const length = colors.length
  colors[length] = 'meizu'
  console.log(colors) // [ 'red', 'nike', 'orange', 'adidas', 'meizu' ]
}

{
  console.log('--------------------数组检测--------------------')
  /*
  * 数组检测*/
  const colors = ['red', 'blue', 'orange']
  if (colors instanceof Array) {
    console.log('colors is array')
  }
  // ES6中新增
  if (Array.isArray(colors)) {
    console.log('colors is array')
  }
}

{
  console.log('--------------------数组转换--------------------')
  /*
  * 数组转换, 对原数组没有影响
  * */
  // 逗号隔开输出字符串
  const colors = ['red', 'blue', 'orange']
  console.log(colors.toString())
  // 特定符号隔开,输出字符串
  console.log(colors.join('@'))
  console.log(colors)
}

{
  console.log('--------------------栈方法--------------------')
  /*
  * 栈方法: 后进先出 push()将数据推入数组  pop()从数据末尾移出一项,都是在原数组上进行操作
  * */
  let colors = []
  colors.push('red', 'blue', 'orange')
  const color = colors.pop()
  console.log(colors)
  console.log(color)
}

{
  console.log('--------------------队列方法--------------------')
  /*
  * 队列方法: 先进先出  push()将数据推入数组,shift()从数组头部移出一项, unshift()将数据推到数据头部,都在原数组上进行操作
  * */
  let colors = []
  colors.push('red', 'blue', 'orange', 'black')
  const color1 = colors.shift()
  console.log(colors)
  const color2 = colors.unshift('wujiedong')
  console.log(colors)
  console.log(color1)
  console.log(color2)
}

{
  /*
  * reverse()对数组中item进行反转,sort()对数组中item比较,传入一个function参数,都在原数组上进行操作,返回经过排序后的数组
  * */
  console.log('--------------------重排序方法--------------------')
  let nums = [2, 1, 8, 3, 5, 7]
  const nums1 = nums.reverse()
  console.log(nums1)
  const nums2 = nums.sort((a, b) => {
    return a - b
  })
  console.log(nums)
  console.log(nums2)
}

{
  /*
  * concat(): 不传参数,直接复制数组,传参数,将参数添加到数据尾部,不会影响原数组的值
  * */
  console.log('--------------------操作方法--------------------')
  console.log('--------------------concat--------------------')
  const colors = ['red', 'blue', 'orange', 'yellow', 'purple']
  const newColors1 = colors.concat()
  console.log(newColors1)
  const newColors2 = newColors1.concat('wuxi', ['suzhou', 'changzhou'])
  console.log(newColors2)
  console.log('原始数组: ', colors)

  /*
  * slice(),基于原始数组,创建一个新数组,不会影响原始数组
  * 只传递一个参数, 指定参数位置,到数组最后,所有item
  * 传递两个参数,从参数1位置开始,到参数2位置结束,包头不包尾
  * */
  console.log('--------------------slice--------------------')
  const newColors3 = colors.slice(1)
  console.log(newColors3)
  const newColors4 = colors.slice(1, 4)
  console.log(newColors4)
  console.log('原始数组: ', colors)

  /*
  * splice(),向数组中部插入值
  * 删除: 两个参数, 参数1: 要删除的第一个位置,参数2: 要删除的项数   返回值: 被删除项组成的数组   会影响原数组
  * 插入: 大于等于三个参数, 参数1: 开始位置 参数2: 0(要删除的项数) 参数3: 要插入的项,多个就是参数4,5,..., 返回值: 空数组  会影响原数组
  * 替换: 三个参数,参数1: 开始位置 参数2: 要删除的项数 参数3: 要插入任意数量的项数数据 返回值:被替换的项数据数组, 会影响原数组
  * */
  console.log('--------------------splice--------------------')
  const citys = ['beijing', 'shanghai', 'guangzhou', 'shenzheng', 'hangzhou']
  const newCitys1 = citys.splice(1, 2)
  console.log(newCitys1) // [ 'shanghai', 'guangzhou' ]
  console.log(citys) // [ 'beijing', 'shenzheng', 'hangzhou' ]

  const newCitys2 = citys.splice(1, 0, 'shanghai', 'guangzhou')
  console.log(newCitys2) // []
  console.log(citys) // [ 'beijing', 'shanghai', 'guangzhou', 'shenzheng', 'hangzhou' ]

  const newCitys3 = citys.splice(2, 1, 'zhangsan', 'lisi')
  console.log(newCitys3) // [ 'guangzhou' ]
  console.log(citys) // [ 'beijing','shanghai','zhangsan','lisi','shenzheng','hangzhou' ]

}

{
  console.log('--------------------位置方法--------------------')
  /*
  * 查找都是用的是 ===
  * indexOf(): 从数组开头开始找,返回值: 所在数组中index,如果没有返回-1
  * lastIndexOf(): 从数组尾部开始找,返回值: 所在数组中index,如果没有返回-1
  * */
  const colors = ['red', 'blue', 'orange', 'yellow', 'purple']
  console.log(colors.indexOf('red')) // 0
  console.log(colors.indexOf('reds')) // -1
}

{
  console.log('--------------------迭代方法--------------------')
  /*
  * 以下5种方法,都不会修改原数组中的值
  * every(): 只有都符合,才会返回true
  * some(): 只要一个符合,就返回true
  * filter(): 对数组进行过滤,对满足条件的item形成一个新数组进行返回,开发中常用,React中使用该函数在JXS中进行列表遍历输出
  * map(): 对原始数组进行遍历,计算,参数是boolean返回值,最终返回一个满足计算条件的新数组
  * forEach(): 参数没有返回值,它是直接对数组进行循环遍历,经此而已
  *
  * */
  const nums = [1, 2, 3, 4, 5]
  const newNums2 = nums.every((item, index) => {
    console.log(index)
    return item > 2
  })
  console.log(newNums2)

  const newNums3 = nums.some((item, index) => {
    console.log(index)
    return item > 2
  })
  console.log(newNums3)

  const persons = [
    {name: 'zhangsan1', age: 19},
    {name: 'zhangsan2', age: 17},
    {name: 'zhangsan3', age: 13},
    {name: 'zhangsan4', age: 21},
    {name: 'zhangsan5', age: 25}
  ]
  const newPersons = persons.filter(item => {
    return item.age > 18
  })
  console.log(newPersons)

  const citys = ['beijing', 'shanghai', 'guangzhou', 'shenzheng', 'hangzhou']
  const newCitys = citys.map(item => {
    return 'china-' + item
  })
  console.log(newCitys)

  const newNums1 = []
  nums.forEach(item => {
    newNums1.push(item * 2)
  })
  console.log(nums)
  console.log(newNums1)
}

{
  console.log('--------------------归并方法--------------------')
  /*
  * reduce(): 从数组头部开始,不会影响原数组
  * reduceRight(): 从数组尾巴开始,不会影响原数组
  * pre: 前一项
  * cur: 当前项
  * index: 索引
  * array: 数组对象
  * 这个函数的返回值作为第一个参数自动传递到下一项,第一次迭代发生在数组的第二项,
  * 综上,pre为数组第一项,cur为数据第二项
  * */
  const nums = [1, 2, 3, 4, 5]
  const sum = nums.reduce((pre, cur, index, array) => {
    return pre + cur
  })
  console.log(nums)
  console.log(sum)

}













































